diff --git a/user_guide/general/changelog.html b/user_guide/general/changelog.html
index bf79a14..5d49967 100644
--- a/user_guide/general/changelog.html
+++ b/user_guide/general/changelog.html
@@ -89,8 +89,11 @@
 <li>Fixed some missing prefixes when using the database prefix feature.</li>
 <li>Fixed a bug that was causing the Loader class to incorrectly identify the file extension.</li>
 <li>Fixed a typo in the Calendar class (cal_november).</li> 
+<li>Fixed a bug in the <dfn>form_checkbox()</dfn> helper.</li>
 <li>Fixed an evaluation bug in the database initialization function.</li>
 <li>Fixed a minor bug in one of the error messages in the language class.</li>
+<li>Fixed an undefined variable in the DB Driver class.</li>
+<li>Fixed a bug in which dollar signs used as binding replacemnt values in the DB class would be treated as RegEx back-references.</li>
 <li>Fixed a bug in the <dfn>set_hash()</dfn> function which was preventing MD5 from being used.</li>
 <li>Fixed a couple bugs in the Unit Testing class.</li>
 <li>Fixed some MS SQL bugs.</li>
